#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
IR 基础类定义
"""

from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Iterator
from enum import Enum, auto
from abc import ABC
from mcpy.symbol_meta import TypeInfo, Symbol, SymbolKind
from mcpy.symbol_registry import SymbolRegistry
import ast

if TYPE_CHECKING:
    from .declarations.annotation import IRAnnotation
    from .module import IRModule
    from .declarations.comment import IRComment
    from mcpy.codegen.core.extension import EmitterCallback


# 全局默认 IRNode 实例，用作默认值，避免重复构造开销
DEFAULT_IR_NODE = None


def get_default_ir_node() -> "IRNode":
    """获取全局默认 IRNode 实例"""
    global DEFAULT_IR_NODE
    if DEFAULT_IR_NODE is None:
        DEFAULT_IR_NODE = IRNode(node_type="default", name="")
    return DEFAULT_IR_NODE


class ProcessStatus(Enum):
    """处理状态枚举"""

    CONTINUE = auto()  # 继续处理
    BREAK = auto()  # 停止处理


@dataclass
class IRNode(ABC):
    """IR节点基类"""

    # 节点类型，类属性
    node_type: str = ""  # "class", "function", "enum", ...

    name: str = field(default="")
    decorators: List[Dict[str, Any]] = field(default_factory=list)
    doc: str = field(default="")
    extension_processed: bool = field(default=False)
    extension_params: Dict[str, Any] = field(default_factory=dict)
    function_calls: List[str] = field(default_factory=list)
    parent: Optional["IRNode"] = field(default=None, repr=False)
    _ir_module_cache: Optional["IRModule"] = field(default=None, repr=False, init=False)
    annotations: List["IRAnnotation"] = field(default_factory=list)
    comment: Optional["IRComment"] = field(default=None)
    _symbol_map: Dict[str, Symbol] = field(default_factory=dict, init=False, repr=False)
    _symbol_cache_built: bool = field(default=False, init=False, repr=False)
    source_line: int = field(default=0)

    def __str__(self):
        return f"{self.node_type} {self.name}"

    def __hash__(self):
        """使 IR 节点可哈希，基于对象 ID"""
        return hash(id(self))

    def __eq__(self, other):
        """IR 节点相等性比较，基于对象身份"""
        return self is other

    def build_from_ast(self, node: ast.AST) -> None:
        """从 AST 节点构建 IR 节点内容

        Args:
            node: AST 节点
        """
        # 提取行号信息
        if hasattr(node, "lineno"):
            self.source_line = getattr(node, "lineno")

    def get_child_nodes(self) -> Iterator["IRNode"]:
        """获取所有子节点

        Returns:
            子节点的迭代器
        """
        for annotation in self.annotations:
            yield annotation

        return iter([])

    def walk(self) -> Iterator["IRNode"]:
        """深度优先遍历所有节点（包括当前节点）"""
        yield self
        for child in self.get_child_nodes():
            yield from child.walk()

    def walk_children(self) -> Iterator["IRNode"]:
        """深度优先遍历所有子节点（不包括当前节点）"""
        for child in self.get_child_nodes():
            yield from child.walk()

    def find_nodes_by_predicate(self, predicate) -> Iterator["IRNode"]:
        """查找满足谓词的所有节点（包括子节点）"""
        for node in self.walk():
            if predicate(node):
                yield node

    # 扩展参数管理方法
    def set_extension_param(
        self, key: str, value: Any, replace_existing: bool = False
    ) -> None:
        """设置扩展参数

        Args:
            key: 参数键名
            value: 参数值
        """
        if not replace_existing and key in self.extension_params:
            return

        self.extension_params[key] = value

    def get_extension_param(self, key: str, default: Any = None) -> Any:
        """获取扩展参数

        Args:
            key: 参数键名
            default: 默认值

        Returns:
            参数值，如果不存在则返回默认值
        """
        return self.extension_params.get(key, default)

    def has_extension_param(self, key: str) -> bool:
        """检查是否存在指定的扩展参数

        Args:
            key: 参数键名

        Returns:
            是否存在该参数
        """
        return key in self.extension_params

    def remove_extension_param(self, key: str) -> Any:
        """移除扩展参数

        Args:
            key: 参数键名

        Returns:
            被移除的参数值，如果不存在则返回None
        """
        return self.extension_params.pop(key, None)

    def update_extension_params(self, params: Dict[str, Any]) -> None:
        """批量更新扩展参数

        Args:
            params: 要更新的参数字典
        """
        self.extension_params.update(params)

    # 类型收窄相关方法
    def get_narrowing_info(self, var_name: str) -> Optional[Any]:
        """获取变量的类型收窄信息

        用于类型收窄系统，在特定代码路径上获取变量的精确类型

        Args:
            var_name: 变量名

        Returns:
            TypeNarrowingInfo 对象，如果没有收窄信息则返回 None

        Examples:
            >>> # 在 if 语句的 then 分支中
            >>> narrowing_info = node.get_narrowing_info("num")
            >>> if narrowing_info:
            ...     print(f"{narrowing_info.original_type} -> {narrowing_info.narrowed_type}")
        """
        active_narrowings = self.get_extension_param("active_narrowings", {})
        return active_narrowings.get(var_name)

    def set_narrowing_info(self, var_name: str, narrowing_info: Any) -> None:
        """设置变量的类型收窄信息

        用于类型守卫分析 Pass，将类型收窄信息附加到节点上

        Args:
            var_name: 变量名
            narrowing_info: TypeNarrowingInfo 对象

        Examples:
            >>> from mcpy.analysis.type_narrowing import TypeNarrowingInfo
            >>> info = TypeNarrowingInfo(
            ...     var_name="num",
            ...     original_type=optional_type,
            ...     narrowed_type=int_type,
            ...     narrowing_kind="optional_unwrap"
            ... )
            >>> node.set_narrowing_info("num", info)
        """
        active_narrowings = self.get_extension_param("active_narrowings", {})
        if not isinstance(active_narrowings, dict):
            active_narrowings = {}
        active_narrowings[var_name] = narrowing_info
        self.set_extension_param(
            "active_narrowings", active_narrowings, replace_existing=True
        )

    def has_narrowing_info(self, var_name: str) -> bool:
        """检查变量是否有类型收窄信息

        Args:
            var_name: 变量名

        Returns:
            是否存在类型收窄信息
        """
        active_narrowings = self.get_extension_param("active_narrowings", {})
        return var_name in active_narrowings

    def get_all_narrowings(self) -> Dict[str, Any]:
        """获取当前节点的所有类型收窄信息

        Returns:
            变量名到 TypeNarrowingInfo 的映射
        """
        return self.get_extension_param("active_narrowings", {})

    def get_cpp_type(self) -> Optional[str]:
        """
        获取节点的 C++ 类型

        优先级：
        1. extension_param 中的 cpp_type（由 type_replacement pass 设置）
        2. 通过符号系统获取类型信息（待实现）

        Returns:
            C++ 类型字符串，如果无法获取则返回 None
        """
        cpp_type = self.get_extension_param("cpp_type")
        if cpp_type:
            return cpp_type

        # TODO: 通过符号系统获取类型信息
        # 类型信息现在通过符号系统管理，需要重构此方法
        return None

    def build_symbol_cache(self) -> None:
        """构建当前节点的符号缓存"""
        if self._symbol_cache_built:
            return

        if self.creates_scope():
            self._symbol_map.clear()
            for symbol in self.get_local_symbols():
                if symbol.name not in self._symbol_map:
                    self._symbol_map[symbol.name] = symbol
                else:
                    old_symbol = self._symbol_map[symbol.name]
                    if symbol.ir_node:
                        symbol.ir_node.set_symbol(old_symbol)
        self._symbol_cache_built = True

    def invalidate_symbol_cache(self) -> None:
        """使符号缓存失效"""
        self._symbol_cache_built = False
        self._symbol_map.clear()
        for child in self.get_child_nodes():
            child.invalidate_symbol_cache()

    def new_symbol(self) -> Symbol:
        """创建当前节点符号

        只有自身可以成为符号的节点才需要实现此方法
        默认实现抛出异常，子类根据需要重写
        """
        raise NotImplementedError("子类需要实现 new_symbol 方法")

    def get_symbol(self, create_if_not_exists: bool = True) -> Symbol:
        """获取当前节点符号"""
        symbol = self.get_extension_param("symbol")
        if symbol or not create_if_not_exists:
            return symbol

        symbol = self.new_symbol()
        if not symbol.ir_node:
            symbol.ir_node = self
        return symbol

    def set_symbol(self, symbol: "Symbol") -> None:
        """设置当前节点符号"""
        if not symbol or "symbol" in self.extension_params:
            return
        self.set_extension_param("symbol", symbol)

    def lookup_symbol(
        self,
        name: str,
        owner_type: Optional[TypeInfo] = None,
        symbol_kinds: Optional[List[SymbolKind]] = None,
        *,
        template_args: Optional[List[TypeInfo]] = None,
        func_args: Optional[List[TypeInfo]] = None,
    ) -> Optional["Symbol"]:
        """在当前节点的作用域及父作用域中查找符号

        Args:
            name: 符号名称
            template_args: 模板参数（用于类型查询）
            func_args: 函数参数（用于函数/方法查询）
            owner_type: 所属类型（用于类方法查找），如果提供则先查找此类型，再在类中查找方法
            symbol_kinds: 要查找的符号类型列表，如 [SymbolKind.VARIABLE, SymbolKind.CLASS]
                         如果为 None，则查找所有类型的符号

        Returns:
            符号信息，如果找不到则返回 None
        """
        # 如果缓存未构建，先构建缓存
        if not self._symbol_cache_built:
            self.build_symbol_cache()

        # 先在当前作用域查找
        if name in self._symbol_map and owner_type is None:
            symbol = self._symbol_map[name]

            # 如果提供了 symbol_kinds，使用精确匹配
            if symbol_kinds is not None:
                if symbol.kind not in symbol_kinds:
                    # 类型不匹配，继续在父作用域查找
                    pass
                elif (
                    func_args is not None
                    and symbol.is_callable()
                    and self._should_check_signature(symbol)
                ):
                    # 提供了参数类型且符号可调用，验证签名
                    if self._signature_matches(symbol, func_args):
                        return symbol
                    # 签名不匹配，继续查找
                else:
                    # 类型匹配，且不需要检查签名
                    return symbol
            else:
                # 未指定 symbol_kinds，查找所有类型
                if (
                    func_args is not None
                    and symbol.is_callable()
                    and self._should_check_signature(symbol)
                ):
                    # 提供了参数类型且符号可调用，验证签名
                    if self._signature_matches(symbol, func_args):
                        return symbol
                    # 签名不匹配，继续查找
                else:
                    # 直接返回符号
                    return symbol

        # 如果提供了 owner_type，说明是查找类方法
        # 跳过当前作用域的缓存，直接从父作用域查找（避免被局部变量覆盖）
        if owner_type is not None:
            # 第一步：查找类类型符号
            parent = self.get_parent_scope()
            if not parent:
                return None

            cls_symbol = parent.lookup_symbol(
                owner_type.name,
                symbol_kinds=[SymbolKind.CLASS],
                template_args=owner_type.args if owner_type.args else None,
            )

            # 第二步：在类中查找方法
            if cls_symbol and cls_symbol.ir_node:
                # 用户自定义类：在类的 IR 节点中查找方法
                full_args_types = [owner_type] + (func_args or [])
                return cls_symbol.ir_node.lookup_symbol(name, func_args=full_args_types)
            else:
                # 内置类型或找不到类符号：使用 SymbolTable 的方法查找
                # 这涵盖了两种情况：
                # 1. cls_symbol 存在但没有 ir_node（内置类型）
                # 2. cls_symbol 不存在（也可能是内置类型，在全局注册表中）
                ir_module = self.get_ir_module()
                if ir_module:
                    # 使用 build_type_signature 获取正确的类型签名字符串
                    from mcpy.symbol_meta import build_type_signature

                    owner_type_str = build_type_signature(owner_type)
                    method_symbol = ir_module.symbol_table.lookup_method_symbol(
                        owner_type_str, name, func_args
                    )

                    # 如果在当前类型中找不到方法，递归查找基类
                    if not method_symbol and owner_type.base_types:
                        for base_type in owner_type.base_types:
                            method_symbol = self.lookup_symbol(
                                name,
                                owner_type=base_type,
                                symbol_kinds=symbol_kinds,
                                func_args=func_args,
                            )
                            if method_symbol:
                                break

                    return method_symbol
                return None
            return None

        # 递归查找父作用域
        parent = self.get_parent_scope()
        if not parent:
            return None

        parent_symbol = parent.lookup_symbol(
            name,
            owner_type=owner_type,
            symbol_kinds=symbol_kinds,
            func_args=func_args,
            template_args=template_args,
        )
        if not parent_symbol:
            return None

        # 如果当前节点具有作用域，且找到的符号是闭包变量，创建闭包变量符号
        if self.creates_scope() and self._is_closure_variable(name, parent_symbol):
            # 注意：不要在这里调用 get_type_info()，因为可能触发类型推导导致循环
            # 闭包变量符号的类型会在需要时通过 ir_node 延迟计算
            return Symbol(
                name=name,
                kind=SymbolKind.CLOSURE_VARIABLE,
                type_info=parent_symbol.type_info,  # 只使用已缓存的类型，不触发推导
                ir_node=parent_symbol.ir_node,
            )
        return parent_symbol

    def creates_scope(self) -> bool:
        return False

    def _should_check_signature(self, symbol: "Symbol") -> bool:
        """判断是否应该对符号进行严格的签名匹配

        Args:
            symbol: 要检查的符号

        Returns:
            bool: 如果应该进行严格签名匹配返回 True
        """
        # 只对本地定义的函数和方法进行严格签名匹配
        # 对于 builtin 函数和导入的函数，使用宽松匹配（因为签名可能不完整）
        if not symbol.ir_node:
            # 没有 IR 节点，可能是 builtin 或导入的函数，使用宽松匹配
            return False

        # 检查是否在当前模块中定义
        current_module = self.get_ir_module()
        symbol_module = symbol.ir_node.get_ir_module()

        # 只有在同一模块中定义的函数/方法才进行严格匹配
        return current_module == symbol_module

    def _signature_matches(self, symbol: "Symbol", args_types: List[TypeInfo]) -> bool:
        """检查符号的签名是否匹配给定的参数类型

        Args:
            symbol: 要检查的符号
            args_types: 参数类型列表

        Returns:
            bool: 如果有匹配的签名返回 True，否则返回 False
        """
        if not symbol.signatures:
            # 没有签名信息，无法匹配，默认返回 True（宽松匹配）
            return True

        # 如果参数类型列表中包含 None，使用宽松匹配
        # None 表示类型推导失败或未知类型，不应该阻止符号查找
        if any(t is None for t in args_types):
            return True

        # 使用符号的 find_matching_signature 方法
        matched = symbol.find_matching_signature(args_types)
        return matched is not None

    def _is_closure_variable(self, name: str, parent_symbol: "Symbol") -> bool:
        """判断一个变量是否是闭包变量

        Args:
            name: 变量名
            parent_symbol: 父作用域中的符号

        Returns:
            如果是闭包变量则返回True
        """
        # 如果父符号是变量或参数，需要检查是否来自具有作用域的父节点
        if parent_symbol.kind in (SymbolKind.VARIABLE, SymbolKind.PARAMETER):
            # 检查符号是否来自具有作用域的节点（而不是模块作用域）
            if parent_symbol.ir_node:
                current_node = parent_symbol.ir_node
                while current_node:
                    parent_node = current_node.get_parent_scope()
                    if parent_node:
                        # 使用 node_type 字符串判断，避免循环导入
                        # 如果来自函数、方法或类作用域，则是闭包变量
                        if parent_node.node_type in ("function", "method", "class"):
                            return True
                        elif parent_node.node_type == "module":
                            return False  # 来自模块作用域，不是闭包变量
                    current_node = parent_node

            return False  # 无法确定作用域，默认不是闭包变量
        return False

    def get_local_symbols(self) -> Iterator[Symbol]:
        """获取当前作用域的所有符号

        注意：这个方法应该被子类重写以提供实际的符号收集逻辑
        基类默认返回空迭代器

        Returns:
            当前作用域符号的迭代器
        """
        return iter([])

    def walk_local_symbols(
        self, kind: SymbolKind = SymbolKind.ANY
    ) -> Iterator["Symbol"]:
        """在当前节点的作用域及父作用域中查找符号

        Args:
            name: 符号名称

        Returns:
            符号信息，如果找不到则返回 None
        """
        # 如果缓存未构建，先构建缓存
        if not self._symbol_cache_built:
            self.build_symbol_cache()

        for symbol in self._symbol_map.values():
            if symbol.kind == kind or kind == SymbolKind.ANY:
                assert symbol.ir_node, f"符号 {symbol.name} 没有关联 IR 节点"
                yield symbol

    def get_cached_symbols(self) -> Iterator[Symbol]:
        """获取缓存的符号（仅在缓存构建后使用）

        Returns:
            缓存符号的迭代器
        """
        # 如果缓存未构建，先构建缓存
        if not self._symbol_cache_built:
            self.build_symbol_cache()
        return iter(self._symbol_map.values())

    def remove_symbol(self, name: str) -> bool:
        """从当前作用域移除符号

        Args:
            name: 符号名称

        Returns:
            是否成功移除符号
        """
        if name in self._symbol_map:
            del self._symbol_map[name]
            return True
        return False

    def has_symbol(self, name: str) -> bool:
        """检查当前作用域是否包含指定符号

        Args:
            name: 符号名称

        Returns:
            是否包含该符号
        """
        # 如果缓存未构建，先构建缓存
        if not self._symbol_cache_built:
            self.build_symbol_cache()
        return name in self._symbol_map

    def find_symbol_ir_node(
        self, symbol_name: str, symbol_kind: SymbolKind = SymbolKind.ANY
    ) -> Optional["IRNode"]:
        """在指定作用域中查找符号的IR节点

        Args:
            symbol_name: 符号名称
            symbol_kind: 符号类型

        Returns:
            符号的IR节点，如果找不到则返回None
        """
        # 优先使用lookup_symbol方法（如果存在）
        symbol = self.lookup_symbol(symbol_name)
        if symbol and (symbol.kind == symbol_kind or symbol_kind == SymbolKind.ANY):
            return symbol.ir_node

        return None

    def get_parent_scope(self) -> Optional["IRNode"]:
        """获取父作用域节点

        Returns:
            父作用域节点，如果没有则返回 None
        """
        current = self.parent
        while current is not None:
            # 跳过语句块，找到真正的作用域节点（函数、方法、类、模块、推导式）
            if current.creates_scope():
                return current
            current = current.parent
        return None

    def set_parent(self, parent: Optional["IRNode"]) -> None:
        """设置父节点

        Args:
            parent: 父节点
        """
        self.parent = parent
        # 清除 IRModule 缓存，因为父节点关系发生了变化
        self._ir_module_cache = None

    def get_ir_module(self) -> Optional["IRModule"]:
        """获取当前节点所属的 IRModule

        使用缓存机制提高查找效率，避免重复向上遍历

        Returns:
            IRModule 节点，如果找不到则返回 None
        """
        # 如果已经缓存了结果，直接返回
        if self._ir_module_cache is not None:
            return self._ir_module_cache

        # 向上查找 IRModule
        current: Any = self
        depth = 0
        while current:
            if current.node_type == "module":
                self._ir_module_cache = current
                return current
            current = current.parent
            depth += 1
            if depth > 100:  # 防止无限循环
                print(f"⚠️  get_ir_module: 超过100层深度，可能存在循环引用！")
                print(
                    f"   起始节点: {self.node_type} {self.name if hasattr(self, 'name') else ''}"
                )
                return None

        return None

    def get_registry(self) -> Optional[SymbolRegistry]:
        """获取符号注册表"""
        module = self.get_ir_module()
        if module is None:
            return None
        return module.get_registry()

    def set_emitter(
        self, callback: "EmitterCallback", replace_existing: bool = False
    ) -> None:
        """注册代码发射器到节点

        Args:
            callback: 代码发射器（简单函数、Emitter 或传统回调）
            replace_existing: 是否替换现有的扩展
        """
        if not replace_existing and self.has_extension_param("emitter_callback"):
            return

        self.set_extension_param("emitter_callback", callback)

    def debug_print(self, mode: str = "tree", **kwargs) -> None:
        """调试打印当前节点

        Args:
            mode: 调试模式，可选 "tree", "detail", "summary"
            **kwargs: 其他参数传递给调试函数
        """
        from .debug import debug_ir_node

        debug_ir_node(self, mode=mode, **kwargs)

    def debug_tree(
        self,
        max_depth: Optional[int] = None,
        show_types: bool = True,
        show_extensions: bool = False,
    ) -> None:
        """以树形结构打印当前节点

        Args:
            max_depth: 最大递归深度
            show_types: 是否显示类型信息
            show_extensions: 是否显示扩展参数
        """
        from .debug import print_ir_tree

        print_ir_tree(
            self,
            max_depth=max_depth,
            show_types=show_types,
            show_extensions=show_extensions,
        )

    def debug_detail(
        self,
        max_depth: Optional[int] = None,
        show_types: bool = True,
        show_extensions: bool = True,
    ) -> None:
        """打印当前节点的详细信息

        Args:
            max_depth: 最大递归深度
            show_types: 是否显示类型信息
            show_extensions: 是否显示扩展参数
        """
        from .debug import print_ir_node

        print_ir_node(
            self,
            max_depth=max_depth,
            show_types=show_types,
            show_extensions=show_extensions,
        )

    def debug_summary(self) -> None:
        """打印当前节点的统计摘要"""
        from .debug import print_ir_summary

        print_ir_summary(self)

    def get_all_extension_params(self) -> Dict[str, Any]:
        """获取所有扩展参数

        Returns:
            扩展参数字典的副本
        """
        return self.extension_params.copy()

    def replace_child_node(self, old_node: "IRNode", new_node: "IRNode") -> bool:
        """替换子节点

        Args:
            old_node: 要被替换的旧节点
            new_node: 新节点

        Returns:
            是否成功替换
        """

        # 复制旧节点的extension_params到新节点（如果新节点没有相同的键）
        if hasattr(old_node, "extension_params") and old_node.extension_params:
            if not hasattr(new_node, "extension_params"):
                new_node.extension_params = {}
            for key, value in old_node.extension_params.items():
                if key not in new_node.extension_params:
                    new_node.extension_params[key] = value

        # 设置新节点的父节点
        new_node.set_parent(self)

        # 遍历所有属性，查找并替换子节点
        for attr_name in dir(self):
            # 跳过私有属性和方法
            if attr_name.startswith("_") or callable(getattr(self, attr_name)):
                continue

            attr_value = getattr(self, attr_name)

            # 处理单个节点属性
            if isinstance(attr_value, IRNode) and attr_value is old_node:
                setattr(self, attr_name, new_node)
                return True

            # 处理节点列表属性
            elif isinstance(attr_value, list):
                for i, item in enumerate(attr_value):
                    if isinstance(item, IRNode) and item is old_node:
                        attr_value[i] = new_node
                        return True

        return False

    def find_and_replace_node(self, predicate, new_node: "IRNode") -> bool:
        """根据条件查找并替换节点

        Args:
            predicate: 查找条件函数，接受一个节点参数，返回布尔值
            new_node: 新节点

        Returns:
            是否成功替换
        """
        # 在当前节点的子节点中查找
        for child in self.get_child_nodes():
            if predicate(child):
                return self.replace_child_node(child, new_node)

        # 递归在子节点中查找
        for child in self.get_child_nodes():
            if child.find_and_replace_node(predicate, new_node):
                return True

        return False


@dataclass
class Parameter(IRNode):
    """参数信息"""

    name: str = field(default="")
    type_annotation: str = field(default="")
    default_value: Optional[Any] = field(default=None)

    node_type: str = "parameter"

    def new_symbol(self) -> "Symbol":
        """创建参数的符号"""
        return Symbol(self.name, SymbolKind.PARAMETER, ir_node=self)

    def get_cpp_type(self):
        """获取参数的C++类型

        优先使用type_inference和parameter_analysis阶段推导并缓存的类型信息，
        确保代码生成阶段不进行类型推导。

        优先级：
        1. optimized_cpp_type - parameter_analysis 综合决策（配置 + 使用模式）
        2. cpp_type - type_replacement 生成的基础类型
        3. 从 inferred_type 转换（回退）
        """
        # 优先：参数分析优化后的类型（已综合考虑配置和使用模式）
        if "optimized_cpp_type" in self.extension_params:
            return self.extension_params["optimized_cpp_type"]

        # 回退到基础的C++类型
        if "cpp_type" in self.extension_params:
            return self.extension_params["cpp_type"]

        # 如果没有缓存的C++类型，但有缓存的类型信息，进行转换（回退）
        cached_type = self.extension_params.get("inferred_type")
        if cached_type:
            # 这里应该在type_replacement阶段已经处理过，但作为后备
            try:
                from ..type_system import get_cpp_type

                cpp_type = get_cpp_type(cached_type, self)
                if cpp_type:
                    # 缓存转换结果避免重复转换
                    self.extension_params["cpp_type"] = cpp_type
                    return cpp_type
            except (ImportError, AttributeError):
                pass

        return self.type_annotation
